import { config } from '../config/index.js'
import {
		login
	} from './login.js'

// 请求拦截器
const requestInterceptor = {
	// 请求前拦截
	invoke(options) {
		// 添加基础URL
		if (!options.url.startsWith('http')) {
			options.url = config.baseUrl + options.url
		}
		
		// 添加请求头
		options.header = options.header || {}
		options.header['Content-Type'] = 'application/json'
		
		// 添加token
		const token = uni.getStorageSync('token')
		if (token) {
			options.header.token = token
		}
		
		// 添加用户信息
		const userInfo = uni.getStorageSync('userInfo')
		if (userInfo && userInfo.id) {
			options.header['User-Id'] = userInfo.id
		}
		
		// 打印请求信息（开发环境）
		if (process.env.NODE_ENV === 'development') {
			console.log('请求拦截器 - 请求信息:', {
				url: options.url,
				method: options.method,
				data: options.data,
				header: options.header
			})
		}
		
		return options
	}
}

// 响应拦截器
const responseInterceptor = {
	// 响应成功拦截
	success(response) {
		// 打印响应信息（开发环境）
		if (process.env.NODE_ENV === 'development') {
			console.log('响应拦截器 - 响应信息:', {
				url: response.config?.url || 'unknown',
				statusCode: response.statusCode,
				data: response.data
			})
		}
		
		// 处理响应状态码
		if (response.statusCode === 200) {
			// 检查业务状态码
			if (response.data && response.data.code !== undefined) {
				if (response.data.code === 0 || response.data.code === 200) {
					// 请求成功
					return response
				} else if (response.data.code === 401) {
					// token过期或无效
					handleTokenExpired()
					return Promise.reject(new Error('登录已过期，请重新登录'))
				} else {
					// 其他业务错误
					const errorMsg = response.data.msg || response.data.message || '请求失败'
					uni.showToast({
						title: errorMsg,
						icon: 'error',
						duration: 2000
					})
					return Promise.reject(new Error(errorMsg))
				}
			}
		} else if (response.statusCode === 401) {
			// HTTP 401 未授权
			handleTokenExpired()
			return Promise.reject(new Error('登录已过期，请重新登录'))
		} else if (response.statusCode === 403) {
			// HTTP 403 禁止访问
			uni.showToast({
				title: '没有访问权限',
				icon: 'error'
			})
			return Promise.reject(new Error('没有访问权限'))
		} else if (response.statusCode === 424) {
			// HTTP 424 Failed Dependency - token过期
			handleTokenExpired()
			return Promise.reject(new Error('登录已过期，请重新登录'))
		} else if (response.statusCode === 404) {
			// HTTP 404 未找到
			uni.showToast({
				title: '请求的资源不存在',
				icon: 'error'
			})
			return Promise.reject(new Error('请求的资源不存在'))
		} else if (response.statusCode >= 500) {
			// HTTP 5xx 服务器错误
			uni.showToast({
				title: '服务器错误，请稍后重试',
				icon: 'error'
			})
			return Promise.reject(new Error('服务器错误'))
		} else {
			// 其他HTTP错误
			uni.showToast({
				title: `请求失败 (${response.statusCode})`,
				icon: 'error'
			})
			return Promise.reject(new Error(`请求失败 (${response.statusCode})`))
		}
		
		return response
	},
	
	// 响应失败拦截
	fail(error) {
		console.error('请求失败:', error)
		
		// 网络错误处理
		if (error.errMsg) {
			if (error.errMsg.includes('timeout')) {
				uni.showToast({
					title: '请求超时，请检查网络',
					icon: 'error'
				})
			} else if (error.errMsg.includes('fail')) {
				uni.showToast({
					title: '网络连接失败',
					icon: 'error'
				})
			} else {
				uni.showToast({
					title: '请求失败，请稍后重试',
					icon: 'error'
				})
			}
		} else {
			uni.showToast({
				title: '网络异常，请检查网络连接',
				icon: 'error'
			})
		}
		
		return Promise.reject(error)
	}
}

// 防重复处理标志
let isHandlingTokenExpired = false

// 处理token过期
function handleTokenExpired() {
	// 防止重复处理
	if (isHandlingTokenExpired) {
		console.log('Token过期处理中，跳过重复处理')
		return
	}

	isHandlingTokenExpired = true
	console.log('Token已过期，清除本地数据')

	// 清除本地存储的用户信息和token
	uni.removeStorageSync('token')
	uni.removeStorageSync('userInfo')

	// 显示提示并触发重新登录
	uni.showModal({
		title: '登录提示',
		content: '登录已过期，请重新登录',
		showCancel: false,
		confirmText: '重新登录',
		success() {
			console.log('用户确认重新登录，触发登录弹窗')
			// 触发重新登录
			triggerReLogin()
		},
		complete() {
			// 无论用户如何操作，都重置标志
			setTimeout(() => {
				isHandlingTokenExpired = false
			}, 1000) // 1秒后重置，避免用户快速操作时的问题
		}
	})
}

	const handlerLogin = () => {
		login((resp) => {
			console.log('登录成功，开始刷新页面数据')

			// 更新用户信息
			const userInfo = uni.getStorageSync('userInfo')
			console.log('登录后的用户信息:', userInfo)

			setTimeout(() => {
				// 使用通用的页面刷新方法
				refreshCurrentPage()

				// 显示登录成功提示
				uni.showToast({
					title: '登录成功',
					icon: 'success',
					duration: 2000
				})
			}, 800) // 增加延迟时间，确保登录流程完全完成
		})
	}
// 触发重新登录
function triggerReLogin() {
	handlerLogin()
}

// 通用的页面刷新方法
function refreshCurrentPage() {
	try {
		// 获取当前页面栈
		const pages = getCurrentPages()
		if (pages.length === 0) {
			console.log('没有找到当前页面')
			return
		}

		const currentPage = pages[pages.length - 1]
		const currentRoute = currentPage.route

		console.log('开始刷新页面:', currentRoute)

		// 方法1: 调用页面的onShow方法
		if (typeof currentPage.onShow === 'function') {
			console.log('调用onShow方法刷新页面')
			currentPage.onShow()
		}

		// 方法2: 调用页面的onLoad方法（如果需要重新初始化）
		if (typeof currentPage.onLoad === 'function' && currentPage.options) {
			console.log('调用onLoad方法重新初始化页面')
			currentPage.onLoad(currentPage.options)
		}

		// 方法3: 触发页面的自定义刷新事件
		if (typeof currentPage.$emit === 'function') {
			currentPage.$emit('refresh')
		}

		console.log('页面刷新完成')

	} catch (error) {
		console.error('刷新页面时发生错误:', error)
	}
}

// 安装拦截器
function setupInterceptors() {
	// 添加请求拦截器
	uni.addInterceptor('request', requestInterceptor)

	// 添加响应拦截器
	uni.addInterceptor('request', responseInterceptor)

	console.log('请求拦截器已安装')
}

// 移除拦截器
function removeInterceptors() {
	uni.removeInterceptor('request')
	console.log('请求拦截器已移除')
}

// 默认导出
export default {
	setupInterceptors,
	removeInterceptors,
	refreshCurrentPage
}

// 命名导出
export {
	setupInterceptors,
	removeInterceptors,
	refreshCurrentPage
}
